using System;
using System.Collections.Generic;
using ns26;
using ns27;

namespace Triton.Game.Mapping
{
	[Attribute38("Actor")]
	public class Actor : MonoBehaviour
	{
		public Vector2 GEM_TEXTURE_OFFSET_RARE => method_2<Vector2>("GEM_TEXTURE_OFFSET_RARE");

		public Vector2 GEM_TEXTURE_OFFSET_EPIC => method_2<Vector2>("GEM_TEXTURE_OFFSET_EPIC");

		public Vector2 GEM_TEXTURE_OFFSET_LEGENDARY => method_2<Vector2>("GEM_TEXTURE_OFFSET_LEGENDARY");

		public Vector2 GEM_TEXTURE_OFFSET_COMMON => method_2<Vector2>("GEM_TEXTURE_OFFSET_COMMON");

		public Color GEM_COLOR_RARE => method_2<Color>("GEM_COLOR_RARE");

		public Color GEM_COLOR_EPIC => method_2<Color>("GEM_COLOR_EPIC");

		public Color GEM_COLOR_LEGENDARY => method_2<Color>("GEM_COLOR_LEGENDARY");

		public Color GEM_COLOR_COMMON => method_2<Color>("GEM_COLOR_COMMON");

		public Color CLASS_COLOR_GENERIC => method_2<Color>("CLASS_COLOR_GENERIC");

		public Color CLASS_COLOR_WARLOCK => method_2<Color>("CLASS_COLOR_WARLOCK");

		public Color CLASS_COLOR_ROGUE => method_2<Color>("CLASS_COLOR_ROGUE");

		public Color CLASS_COLOR_DRUID => method_2<Color>("CLASS_COLOR_DRUID");

		public Color CLASS_COLOR_SHAMAN => method_2<Color>("CLASS_COLOR_SHAMAN");

		public Color CLASS_COLOR_HUNTER => method_2<Color>("CLASS_COLOR_HUNTER");

		public Color CLASS_COLOR_MAGE => method_2<Color>("CLASS_COLOR_MAGE");

		public Color CLASS_COLOR_PALADIN => method_2<Color>("CLASS_COLOR_PALADIN");

		public Color CLASS_COLOR_PRIEST => method_2<Color>("CLASS_COLOR_PRIEST");

		public Color CLASS_COLOR_WARRIOR => method_2<Color>("CLASS_COLOR_WARRIOR");

		public Color CLASS_COLOR_DEATHKNIGHT => method_2<Color>("CLASS_COLOR_DEATHKNIGHT");

		public GameObject m_cardMesh => method_3<GameObject>("m_cardMesh");

		public int m_cardFrontMatIdx => method_2<int>("m_cardFrontMatIdx");

		public int m_cardBackMatIdx => method_2<int>("m_cardBackMatIdx");

		public int m_premiumRibbon => method_2<int>("m_premiumRibbon");

		public GameObject m_portraitMesh => method_3<GameObject>("m_portraitMesh");

		public int m_portraitFrameMatIdx => method_2<int>("m_portraitFrameMatIdx");

		public int m_portraitMatIdx => method_2<int>("m_portraitMatIdx");

		public GameObject m_nameBannerMesh => method_3<GameObject>("m_nameBannerMesh");

		public GameObject m_descriptionMesh => method_3<GameObject>("m_descriptionMesh");

		public GameObject m_descriptionTrimMesh => method_3<GameObject>("m_descriptionTrimMesh");

		public GameObject m_rarityFrameMesh => method_3<GameObject>("m_rarityFrameMesh");

		public GameObject m_rarityGemMesh => method_3<GameObject>("m_rarityGemMesh");

		public GameObject m_racePlateMesh => method_3<GameObject>("m_racePlateMesh");

		public GameObject m_attackObject => method_3<GameObject>("m_attackObject");

		public GameObject m_healthObject => method_3<GameObject>("m_healthObject");

		public GameObject m_armorObject => method_3<GameObject>("m_armorObject");

		public GameObject m_manaObject => method_3<GameObject>("m_manaObject");

		public GameObject m_racePlateObject => method_3<GameObject>("m_racePlateObject");

		public GameObject m_cardTypeAnchorObject => method_3<GameObject>("m_cardTypeAnchorObject");

		public GameObject m_eliteObject => method_3<GameObject>("m_eliteObject");

		public GameObject m_classIconObject => method_3<GameObject>("m_classIconObject");

		public GameObject m_heroSpotLight => method_3<GameObject>("m_heroSpotLight");

		public GameObject m_glints => method_3<GameObject>("m_glints");

		public GameObject m_armorSpellBone => method_3<GameObject>("m_armorSpellBone");

		public NestedPrefab m_multiClassBannerContainer => method_3<NestedPrefab>("m_multiClassBannerContainer");

		public UberText m_costTextMesh => method_3<UberText>("m_costTextMesh");

		public UberText m_attackTextMesh => method_3<UberText>("m_attackTextMesh");

		public UberText m_healthTextMesh => method_3<UberText>("m_healthTextMesh");

		public UberText m_armorTextMesh => method_3<UberText>("m_armorTextMesh");

		public UberText m_nameTextMesh => method_3<UberText>("m_nameTextMesh");

		public UberText m_powersTextMesh => method_3<UberText>("m_powersTextMesh");

		public UberText m_raceTextMesh => method_3<UberText>("m_raceTextMesh");

		public UberText m_secretText => method_3<UberText>("m_secretText");

		public GameObject m_missingCardEffect => method_3<GameObject>("m_missingCardEffect");

		public GameObject m_ghostCardGameObject => method_3<GameObject>("m_ghostCardGameObject");

		public string m_spellTablePrefab => method_4("m_spellTablePrefab");

		public Card m_card => method_3<Card>("m_card");

		public Entity m_entity => method_3<Entity>("m_entity");

		public CardDefHandle m_cardDefHandle => method_2<CardDefHandle>("m_cardDefHandle");

		public EntityDef m_entityDef => method_3<EntityDef>("m_entityDef");

		public TAG_PREMIUM m_premiumType => method_2<TAG_PREMIUM>("m_premiumType");

		public ProjectedShadow m_projectedShadow => method_3<ProjectedShadow>("m_projectedShadow");

		public bool m_shown => method_2<bool>("m_shown");

		public ActorStateMgr m_actorStateMgr => method_3<ActorStateMgr>("m_actorStateMgr");

		public ActorStateType m_actorState => method_2<ActorStateType>("m_actorState");

		public bool forceIdleState => method_2<bool>("forceIdleState");

		public GameObject m_rootObject => method_3<GameObject>("m_rootObject");

		public GameObject m_bones => method_3<GameObject>("m_bones");

		public MeshRenderer m_meshRenderer => method_3<MeshRenderer>("m_meshRenderer");

		public int m_legacyPortraitMaterialIndex => method_2<int>("m_legacyPortraitMaterialIndex");

		public int m_legacyCardColorMaterialIndex => method_2<int>("m_legacyCardColorMaterialIndex");

		public Material m_initialPortraitMaterial => method_3<Material>("m_initialPortraitMaterial");

		public Material m_initialPremiumRibbonMaterial => method_3<Material>("m_initialPremiumRibbonMaterial");

		public List<Material> m_lightBlendMaterials => method_3<Class271<Material>>("m_lightBlendMaterials")?.method_25();

		public List<UberText> m_lightBlendUberText => method_3<Class271<UberText>>("m_lightBlendUberText")?.method_25();

		public SpellTable m_sharedSpellTable => method_3<SpellTable>("m_sharedSpellTable");

		public bool m_useSharedSpellTable => method_2<bool>("m_useSharedSpellTable");

		public SpellTable m_spellTable => method_3<SpellTable>("m_spellTable");

		public ArmorSpell m_armorSpell => method_3<ArmorSpell>("m_armorSpell");

		public GameObject m_hiddenCardStandIn => method_3<GameObject>("m_hiddenCardStandIn");

		public bool m_shadowform => method_2<bool>("m_shadowform");

		public GhostCard.Type m_ghostCard => method_2<GhostCard.Type>("m_ghostCard");

		public bool m_missingcard => method_2<bool>("m_missingcard");

		public bool m_armorSpellLoading => method_2<bool>("m_armorSpellLoading");

		public bool m_materialEffectsSeeded => method_2<bool>("m_materialEffectsSeeded");

		public bool m_ignoreUpdateCardback => method_2<bool>("m_ignoreUpdateCardback");

		public bool isPortraitMaterialDirty => method_2<bool>("isPortraitMaterialDirty");

		public bool m_DisablePremiumPortrait => method_2<bool>("m_DisablePremiumPortrait");

		public Texture m_portraitTextureOverride => method_3<Texture>("m_portraitTextureOverride");

		public bool m_blockTextComponentUpdate => method_2<bool>("m_blockTextComponentUpdate");

		public bool m_armorSpellDisabledForTransition => method_2<bool>("m_armorSpellDisabledForTransition");

		public MultiClassBannerTransition m_multiClassBanner => method_3<MultiClassBannerTransition>("m_multiClassBanner");

		public UberShaderController m_uberShaderController => method_3<UberShaderController>("m_uberShaderController");

		public ActorStateType m_actualState => method_2<ActorStateType>("m_actualState");

		public bool m_hideActorState => method_2<bool>("m_hideActorState");

		public Actor(IntPtr address, string className)
			: base(address, className)
		{
		}

		public Actor(IntPtr address)
			: this(address, "Actor")
		{
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnEnable()
		{
			method_8("OnEnable");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void Init()
		{
			method_8("Init");
		}

		public void Destroy()
		{
			method_8("Destroy");
		}

		public Actor Clone()
		{
			return method_14<Actor>("Clone", Array.Empty<object>());
		}

		public Card GetCard()
		{
			return method_14<Card>("GetCard", Array.Empty<object>());
		}

		public void SetCard(Card card)
		{
			method_8("SetCard", card);
		}

		public CardDef GetCardDef()
		{
			return method_14<CardDef>("GetCardDef", Array.Empty<object>());
		}

		public void SetCardDef(CardDef cardDef)
		{
			method_8("SetCardDef", cardDef);
		}

		public Entity GetEntity()
		{
			return method_14<Entity>("GetEntity", Array.Empty<object>());
		}

		public void SetEntity(Entity entity)
		{
			method_8("SetEntity", entity);
		}

		public EntityDef GetEntityDef()
		{
			return method_14<EntityDef>("GetEntityDef", Array.Empty<object>());
		}

		public void SetEntityDef(EntityDef entityDef)
		{
			method_8("SetEntityDef", entityDef);
		}

		public void SetPremium(TAG_PREMIUM premium)
		{
			method_8("SetPremium", premium);
		}

		public TAG_PREMIUM GetPremium()
		{
			return method_11<TAG_PREMIUM>("GetPremium", Array.Empty<object>());
		}

		public TAG_CARD_SET GetCardSet()
		{
			return method_11<TAG_CARD_SET>("GetCardSet", Array.Empty<object>());
		}

		public ActorStateType GetActorStateType()
		{
			return method_11<ActorStateType>("GetActorStateType", Array.Empty<object>());
		}

		public void ShowActorState()
		{
			method_8("ShowActorState");
		}

		public void HideActorState()
		{
			method_8("HideActorState");
		}

		public void SetActorState(ActorStateType stateType)
		{
			method_8("SetActorState", stateType);
		}

		public void ToggleForceIdle(bool bOn)
		{
			method_8("ToggleForceIdle", bOn);
		}

		public void TurnOffCollider()
		{
			method_8("TurnOffCollider");
		}

		public void TurnOnCollider()
		{
			method_8("TurnOnCollider");
		}

		public void ToggleCollider(bool enabled)
		{
			method_8("ToggleCollider", enabled);
		}

		public bool IsColliderEnabled()
		{
			return method_11<bool>("IsColliderEnabled", Array.Empty<object>());
		}

		public TAG_RARITY GetRarity()
		{
			return method_11<TAG_RARITY>("GetRarity", Array.Empty<object>());
		}

		public bool IsElite()
		{
			return method_11<bool>("IsElite", Array.Empty<object>());
		}

		public bool IsMultiClass()
		{
			return method_11<bool>("IsMultiClass", Array.Empty<object>());
		}

		public void SetHiddenStandIn(GameObject standIn)
		{
			method_8("SetHiddenStandIn", standIn);
		}

		public GameObject GetHiddenStandIn()
		{
			return method_14<GameObject>("GetHiddenStandIn", Array.Empty<object>());
		}

		public void SetShadowform(bool shadowform)
		{
			method_8("SetShadowform", shadowform);
		}

		public void SetDisablePremiumPortrait(bool disable)
		{
			method_8("SetDisablePremiumPortrait", disable);
		}

		public UberShaderController GetUberShaderController()
		{
			return method_14<UberShaderController>("GetUberShaderController", Array.Empty<object>());
		}

		public bool IsShown()
		{
			return method_11<bool>("IsShown", Array.Empty<object>());
		}

		public void Show()
		{
			method_9("Show", new Class276.Enum20[0]);
		}

		public void Show(bool ignoreSpells)
		{
			method_9("Show", new Class276.Enum20[1] { Class276.Enum20.Boolean }, ignoreSpells);
		}

		public void ShowSpellTable()
		{
			method_8("ShowSpellTable");
		}

		public void Hide()
		{
			method_9("Hide", new Class276.Enum20[0]);
		}

		public void Hide(bool ignoreSpells)
		{
			method_9("Hide", new Class276.Enum20[1] { Class276.Enum20.Boolean }, ignoreSpells);
		}

		public void HideSpellTable()
		{
			method_8("HideSpellTable");
		}

		public void ShowImpl(bool ignoreSpells)
		{
			method_8("ShowImpl", ignoreSpells);
		}

		public void HideImpl(bool ignoreSpells)
		{
			method_8("HideImpl", ignoreSpells);
		}

		public ActorStateMgr GetActorStateMgr()
		{
			return method_14<ActorStateMgr>("GetActorStateMgr", Array.Empty<object>());
		}

		public Collider GetCollider()
		{
			return method_14<Collider>("GetCollider", Array.Empty<object>());
		}

		public GameObject GetRootObject()
		{
			return method_14<GameObject>("GetRootObject", Array.Empty<object>());
		}

		public MeshRenderer GetMeshRenderer()
		{
			return method_14<MeshRenderer>("GetMeshRenderer", Array.Empty<object>());
		}

		public GameObject GetBones()
		{
			return method_14<GameObject>("GetBones", Array.Empty<object>());
		}

		public UberText GetPowersText()
		{
			return method_14<UberText>("GetPowersText", Array.Empty<object>());
		}

		public UberText GetRaceText()
		{
			return method_14<UberText>("GetRaceText", Array.Empty<object>());
		}

		public UberText GetNameText()
		{
			return method_14<UberText>("GetNameText", Array.Empty<object>());
		}

		public GameObject FindBone(string boneName)
		{
			return method_14<GameObject>("FindBone", new object[1] { boneName });
		}

		public GameObject GetCardTypeBannerAnchor()
		{
			return method_14<GameObject>("GetCardTypeBannerAnchor", Array.Empty<object>());
		}

		public UberText GetAttackText()
		{
			return method_14<UberText>("GetAttackText", Array.Empty<object>());
		}

		public GameObject GetAttackTextObject()
		{
			return method_14<GameObject>("GetAttackTextObject", Array.Empty<object>());
		}

		public GemObject GetAttackObject()
		{
			return method_14<GemObject>("GetAttackObject", Array.Empty<object>());
		}

		public GemObject GetHealthObject()
		{
			return method_14<GemObject>("GetHealthObject", Array.Empty<object>());
		}

		public UberText GetHealthText()
		{
			return method_14<UberText>("GetHealthText", Array.Empty<object>());
		}

		public GameObject GetHealthTextObject()
		{
			return method_14<GameObject>("GetHealthTextObject", Array.Empty<object>());
		}

		public UberText GetCostText()
		{
			return method_14<UberText>("GetCostText", Array.Empty<object>());
		}

		public GameObject GetCostTextObject()
		{
			return method_14<GameObject>("GetCostTextObject", Array.Empty<object>());
		}

		public UberText GetSecretText()
		{
			return method_14<UberText>("GetSecretText", Array.Empty<object>());
		}

		public void UpdateAllComponents()
		{
			method_8("UpdateAllComponents");
		}

		public bool MissingCardEffect()
		{
			return method_11<bool>("MissingCardEffect", Array.Empty<object>());
		}

		public void DisableMissingCardEffect()
		{
			method_8("DisableMissingCardEffect");
		}

		public void UpdateMissingCardArt()
		{
			method_8("UpdateMissingCardArt");
		}

		public void SetMissingCardMaterial(Material missingCardMat)
		{
			method_8("SetMissingCardMaterial", missingCardMat);
		}

		public bool isMissingCard()
		{
			return method_11<bool>("isMissingCard", Array.Empty<object>());
		}

		public void GhostCardEffect(GhostCard.Type ghostType)
		{
			method_8("GhostCardEffect", ghostType);
		}

		public void UpdateGhostCardEffect()
		{
			method_8("UpdateGhostCardEffect");
		}

		public bool isGhostCard()
		{
			return method_11<bool>("isGhostCard", Array.Empty<object>());
		}

		public void UpdateMaterials()
		{
			method_8("UpdateMaterials");
		}

		public void OverrideAllMeshMaterials(Material material)
		{
			method_8("OverrideAllMeshMaterials", material);
		}

		public void SetUnlit()
		{
			method_8("SetUnlit");
		}

		public void SetLit()
		{
			method_8("SetLit");
		}

		public void SetLightingBlend(float value)
		{
			method_8("SetLightingBlend", value);
		}

		public void SetLightBlend(float blendValue)
		{
			method_8("SetLightBlend", blendValue);
		}

		public void ReleasePortrait()
		{
			method_8("ReleasePortrait");
		}

		public void RecursivelyReplaceMaterialsList(Transform transformToRecurse, Material newMaterialPrefab)
		{
			method_8("RecursivelyReplaceMaterialsList", transformToRecurse, newMaterialPrefab);
		}

		public void ReplaceMaterialsList(Renderer renderer, Material newMaterialPrefab)
		{
			method_8("ReplaceMaterialsList", renderer, newMaterialPrefab);
		}

		public Material CreateReplacementMaterial(Material oldMaterial, Material newMaterialPrefab)
		{
			return method_14<Material>("CreateReplacementMaterial", new object[2] { oldMaterial, newMaterialPrefab });
		}

		public void SeedMaterialEffects()
		{
			method_8("SeedMaterialEffects");
		}

		public void MaterialShaderAnimation(bool animationEnabled)
		{
			method_8("MaterialShaderAnimation", animationEnabled);
		}

		public Player.Side GetCardBackSide()
		{
			return method_11<Player.Side>("GetCardBackSide", Array.Empty<object>());
		}

		public bool GetCardbackUpdateIgnore()
		{
			return method_11<bool>("GetCardbackUpdateIgnore", Array.Empty<object>());
		}

		public void SetCardbackUpdateIgnore(bool ignoreUpdate)
		{
			method_8("SetCardbackUpdateIgnore", ignoreUpdate);
		}

		public void UpdateCardBack()
		{
			method_8("UpdateCardBack");
		}

		public void UpdateCardBackDragEffect()
		{
			method_8("UpdateCardBackDragEffect");
		}

		public void UpdateCardBackDisplay(bool friendlySide)
		{
			method_8("UpdateCardBackDisplay", friendlySide);
		}

		public void UpdateTextures()
		{
			method_8("UpdateTextures");
		}

		public void UpdatePortraitTexture()
		{
			method_8("UpdatePortraitTexture");
		}

		public void SetPortraitTexture(Texture texture)
		{
			method_8("SetPortraitTexture", texture);
		}

		public void SetPortraitTextureOverride(Texture portrait)
		{
			method_8("SetPortraitTextureOverride", portrait);
		}

		public Texture GetPortraitTexture()
		{
			return method_14<Texture>("GetPortraitTexture", Array.Empty<object>());
		}

		public Texture GetStaticPortraitTexture()
		{
			return method_14<Texture>("GetStaticPortraitTexture", Array.Empty<object>());
		}

		public void UpdatePortraitMaterialAnimation()
		{
			method_8("UpdatePortraitMaterialAnimation");
		}

		public void SetPortraitMaterial(Material material)
		{
			method_8("SetPortraitMaterial", material);
		}

		public GameObject GetPortraitMesh()
		{
			return method_14<GameObject>("GetPortraitMesh", Array.Empty<object>());
		}

		public Material GetPortraitMaterial()
		{
			return method_14<Material>("GetPortraitMaterial", Array.Empty<object>());
		}

		public void SetBlockTextComponentUpdate(bool block)
		{
			method_8("SetBlockTextComponentUpdate", block);
		}

		public void UpdateTextComponents()
		{
			method_9("UpdateTextComponents", new Class276.Enum20[0]);
		}

		public void UpdateTextComponentsDef(EntityDef entityDef)
		{
			method_8("UpdateTextComponentsDef", entityDef);
		}

		public void UpdateCostTextMesh(EntityDef entityDef)
		{
			method_9("UpdateCostTextMesh", new Class276.Enum20[1] { Class276.Enum20.Class }, entityDef);
		}

		public void UpdateAttackTextMesh(EntityDef entityDef)
		{
			method_9("UpdateAttackTextMesh", new Class276.Enum20[1] { Class276.Enum20.Class }, entityDef);
		}

		public void UpdateHealthTextMesh(EntityDef entityDef)
		{
			method_9("UpdateHealthTextMesh", new Class276.Enum20[1] { Class276.Enum20.Class }, entityDef);
		}

		public void UpdateArmorTextMesh(EntityDef entityDef)
		{
			method_9("UpdateArmorTextMesh", new Class276.Enum20[1] { Class276.Enum20.Class }, entityDef);
		}

		public void UpdateMinionStatsImmediately()
		{
			method_8("UpdateMinionStatsImmediately");
		}

		public void UpdateTextComponents(Entity entity)
		{
			method_9("UpdateTextComponents", new Class276.Enum20[1] { Class276.Enum20.Class }, entity);
		}

		public void UpdateCostTextMesh(Entity entity)
		{
			method_9("UpdateCostTextMesh", new Class276.Enum20[1] { Class276.Enum20.Class }, entity);
		}

		public void UpdateAttackTextMesh(Entity entity)
		{
			method_9("UpdateAttackTextMesh", new Class276.Enum20[1] { Class276.Enum20.Class }, entity);
		}

		public void UpdateHealthTextMesh(Entity entity)
		{
			method_9("UpdateHealthTextMesh", new Class276.Enum20[1] { Class276.Enum20.Class }, entity);
		}

		public void UpdateArmorTextMesh(Entity entity)
		{
			method_9("UpdateArmorTextMesh", new Class276.Enum20[1] { Class276.Enum20.Class }, entity);
		}

		public void UpdatePowersText()
		{
			method_8("UpdatePowersText");
		}

		public bool ShouldUseEntityDefForPowersText()
		{
			return method_11<bool>("ShouldUseEntityDefForPowersText", Array.Empty<object>());
		}

		public void UpdateNumberText(UberText textMesh, string newText)
		{
			method_9("UpdateNumberText", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String
			}, textMesh, newText);
		}

		public void UpdateNumberText(UberText textMesh, string newText, bool shouldHide)
		{
			method_9("UpdateNumberText", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String,
				Class276.Enum20.Boolean
			}, textMesh, newText, shouldHide);
		}

		public void UpdateNameText(bool useShortName)
		{
			method_8("UpdateNameText", useShortName);
		}

		public void UpdateSecretAndQuestText()
		{
			method_8("UpdateSecretAndQuestText");
		}

		public void UpdateText(UberText uberTextMesh, string text)
		{
			method_8("UpdateText", uberTextMesh, text);
		}

		public void UpdateTextColor(UberText originalMesh, int defNumber, int currentNumber)
		{
			method_9("UpdateTextColor", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.I4,
				Class276.Enum20.I4
			}, originalMesh, defNumber, currentNumber);
		}

		public void UpdateTextColor(UberText uberTextMesh, int defNumber, int currentNumber, bool higherIsBetter)
		{
			method_9("UpdateTextColor", new Class276.Enum20[4]
			{
				Class276.Enum20.Class,
				Class276.Enum20.I4,
				Class276.Enum20.I4,
				Class276.Enum20.Boolean
			}, uberTextMesh, defNumber, currentNumber, higherIsBetter);
		}

		public void UpdateTextColorToGreenOrWhite(UberText uberTextMesh, int defNumber, int currentNumber)
		{
			method_8("UpdateTextColorToGreenOrWhite", uberTextMesh, defNumber, currentNumber);
		}

		public void DisableTextMesh(UberText mesh)
		{
			method_8("DisableTextMesh", mesh);
		}

		public void OverrideNameText(UberText newText, bool useShortName)
		{
			method_8("OverrideNameText", newText, useShortName);
		}

		public void HideAllText()
		{
			method_8("HideAllText");
		}

		public void ShowAllText()
		{
			method_8("ShowAllText");
		}

		public void ToggleTextVisibility(bool bOn)
		{
			method_8("ToggleTextVisibility", bOn);
		}

		public void ContactShadow(bool visible)
		{
			method_8("ContactShadow", visible);
		}

		public void UpdateMeshComponents()
		{
			method_8("UpdateMeshComponents");
		}

		public void UpdateRarityComponent()
		{
			method_8("UpdateRarityComponent");
		}

		public void UpdateDescriptionMesh()
		{
			method_8("UpdateDescriptionMesh");
		}

		public void UpdateWatermark()
		{
			method_8("UpdateWatermark");
		}

		public void UpdateEliteComponent()
		{
			method_8("UpdateEliteComponent");
		}

		public void UpdatePremiumComponents()
		{
			method_8("UpdatePremiumComponents");
		}

		public void UpdateRace(string raceText)
		{
			method_8("UpdateRace", raceText);
		}

		public MultiClassBannerTransition GetMultiClassBanner()
		{
			return method_14<MultiClassBannerTransition>("GetMultiClassBanner", Array.Empty<object>());
		}

		public void UpdateCardColor()
		{
			method_8("UpdateCardColor");
		}

		public void SetMaterial(TAG_CARDTYPE cardType, CardColorSwitcher.CardColorType colorType, Color cardColor)
		{
			method_8("SetMaterial", cardType, colorType, cardColor);
		}

		public void SetMaterialGolden(Color cardColor)
		{
			method_8("SetMaterialGolden", cardColor);
		}

		public void SetMaterialNormal(TAG_CARDTYPE cardType, CardColorSwitcher.CardColorType colorType, Color cardColor)
		{
			method_8("SetMaterialNormal", cardType, colorType, cardColor);
		}

		public void SetMaterialWithTexture(TAG_CARDTYPE cardType, CardColorSwitcher.CardColorType colorType)
		{
			method_8("SetMaterialWithTexture", cardType, colorType);
		}

		public void SetMaterialHero(TAG_CARDTYPE cardType, CardColorSwitcher.CardColorType colorType, Color cardColor)
		{
			method_8("SetMaterialHero", cardType, colorType, cardColor);
		}

		public void SetMaterialWeapon(CardColorSwitcher.CardColorType colorType, Color cardColor)
		{
			method_8("SetMaterialWeapon", colorType, cardColor);
		}

		public HistoryCard GetHistoryCard()
		{
			return method_14<HistoryCard>("GetHistoryCard", Array.Empty<object>());
		}

		public HistoryChildCard GetHistoryChildCard()
		{
			return method_14<HistoryChildCard>("GetHistoryChildCard", Array.Empty<object>());
		}

		public void SetHistoryItem(HistoryItem card)
		{
			method_8("SetHistoryItem", card);
		}

		public SpellTable GetSpellTable()
		{
			return method_14<SpellTable>("GetSpellTable", Array.Empty<object>());
		}

		public Spell LoadSpell(SpellType spellType)
		{
			return method_14<Spell>("LoadSpell", new object[1] { spellType });
		}

		public Spell GetLoadedSpell(SpellType spellType)
		{
			return method_14<Spell>("GetLoadedSpell", new object[1] { spellType });
		}

		public Spell ActivateTaunt()
		{
			return method_14<Spell>("ActivateTaunt", Array.Empty<object>());
		}

		public void DeactivateTaunt()
		{
			method_8("DeactivateTaunt");
		}

		public Spell GetSpell(SpellType spellType)
		{
			return method_14<Spell>("GetSpell", new object[1] { spellType });
		}

		public Spell GetSpellIfLoaded(SpellType spellType)
		{
			return method_15<Spell>("GetSpellIfLoaded", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { spellType });
		}

		public Spell ActivateSpellBirthState(SpellType spellType)
		{
			return method_14<Spell>("ActivateSpellBirthState", new object[1] { spellType });
		}

		public bool IsSpellActive(SpellType spellType)
		{
			return method_11<bool>("IsSpellActive", new object[1] { spellType });
		}

		public void ActivateSpellDeathState(SpellType spellType)
		{
			method_8("ActivateSpellDeathState", spellType);
		}

		public void ActivateAllSpellsDeathStates()
		{
			method_8("ActivateAllSpellsDeathStates");
		}

		public void DoCardDeathVisuals()
		{
			method_8("DoCardDeathVisuals");
		}

		public void DeactivateAllSpells()
		{
			method_8("DeactivateAllSpells");
		}

		public void DestroySpell(SpellType spellType)
		{
			method_8("DestroySpell", spellType);
		}

		public void DisableArmorSpellForTransition()
		{
			method_8("DisableArmorSpellForTransition");
		}

		public void EnableArmorSpellAfterTransition()
		{
			method_8("EnableArmorSpellAfterTransition");
		}

		public void HideArmorSpell()
		{
			method_8("HideArmorSpell");
		}

		public void ShowArmorSpell()
		{
			method_8("ShowArmorSpell");
		}

		public void UpdateRootObjectSpellComponents()
		{
			method_8("UpdateRootObjectSpellComponents");
		}

		public void UpdateArmorSpell()
		{
			method_8("UpdateArmorSpell");
		}

		public void OnSpellStateStarted(Spell spell, SpellStateType prevStateType, object userData)
		{
			method_8("OnSpellStateStarted", spell, prevStateType, userData);
		}

		public void AssignRootObject()
		{
			method_8("AssignRootObject");
		}

		public void AssignBones()
		{
			method_8("AssignBones");
		}

		public void AssignMeshRenderers()
		{
			method_8("AssignMeshRenderers");
		}

		public void AssignMaterials(MeshRenderer meshRenderer)
		{
			method_8("AssignMaterials", meshRenderer);
		}

		public void AssignSpells()
		{
			method_8("AssignSpells");
		}

		public void LoadArmorSpell()
		{
			method_8("LoadArmorSpell");
		}

		public void OnArmorSpellLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnArmorSpellLoaded", assetRef, go, callbackData);
		}
	}
}
